// pages/promotionAdmin/index.ts
import {
    ARTICLE_TYPE_LIST,
    MAIN_TASK_TYPE_LIST,
    PUBLIC_ACCOUNT_STATE_LIST,
    PUBLIC_ACCOUNT_STATUS_LIST,
} from "../../utils/enmu";
import {
    taskExecuteClipboard,
    taskExecuteRoute, taskExecuteShare,
    taskProjectPage
} from "../../service/api/api-promotion";
import {fontSizeCalc, getCountInfo, handleCode, handleErrCode, isWXMP, silentLogin} from "../../utils/util";

let toast;
Page({

    /**
     * 页面的初始数据
     */
    data: {
        searchText: "",// 搜索关键字
        currentTab: 0, // 当前选中的tab
        collapseIndex: 0, // 当前主任务展开的下标
        collapseSecIndex: 0, // 当前子任务展开的下标
        scrollTop: 0, // 滚动到顶部
        tabs: [
            {name: "进行中"},
            {name: "已结束"},
            {name: "已暂停"},
            // {name: "已完成"}
        ],// 筛选条件
        backTaskList: [],// 任务列表
        taskList: [],// 任务列表
        access: {} as any,// 当前用户权限
        currentUser: {},// 当前用户信息
        options: '',
        triggered: false,// 自定义下拉是否被触发 true 表示下拉刷新已经被触发，false 表示下拉刷新未被触发
        isWxmp: false,// 当前是否从公众号模板跳转过来的
        searchTimeout: null,
        current: 1,// 第几页
        pageSize: 20,// 每页多少条数据
        total: 0,// 总共有多少条

        tabFontSize: fontSizeCalc(28)
    },
    /**
     * 开始搜索
     * @param detail
     * @param showLoading
     * @param current 分页数据，
     */
    async searchFun({detail = {value: ''},current = 1}) {
        // 有传值的时候才把这个值设置进去
        let _that = this;
        let {pageSize,currentTab} = this.data;
        // if (_that.isEnd()){
        //     return
        // }
        _that.setData({
            current: current,
            searchText: detail.value
        })
        wx.showLoading({
            title: '搜索中...'
        })
        // 执行搜索函数
        await taskProjectPage({
            current,
            pageSize,
            name: detail.value,
            run: currentTab + 1,
        }).then(async (response) => {
            _that.handleListData(response)
        }).catch(error => {
            console.warn(error)
            handleErrCode(error, 'none')
        }).finally(() => {
            _that.searchFinally()
        })
    },
    /**
     * 搜索取消
     */
    searchCancel() {
        console.log('chCancel');
        this.setData({
            searchText: ""
        })
        this.searchFun({});// 开始搜索
    },
    /**
     * 切换tab
     * @param detail
     */
    tabsChange({detail = {index: 0}}) {
        this.setData({
            currentTab: detail.index,
            scrollTop: 0,
            current: 1,
            total: 0,
            searchText: ""
        })
        this.searchFun({});// 开始搜索
        // 先做本地过滤
        // let currentTab = detail.index;
        // let {backTaskList} = this.data;
        //
        // let curList = backTaskList.filter(item =>{
        //     return detail.index + 1 === item.run
        // })
        // this.setData({
        //     taskList: curList,
        //     currentTab,
        //     scrollTop: 0,
        // })
    },

    /**
     * 处理一下文章类型
     * @param type
     */
    handleArticleType(type: Number) {
        return ARTICLE_TYPE_LIST.find(item => item.value === Number(type)) || {}
    },

    /**
     * 处理一下任务状态
     * @param type
     */
    handleMainTaskType(type: Number) {
        return MAIN_TASK_TYPE_LIST.find(item => item.value === Number(type)) || {}
    },

    /**
     * 处理一下公众号任务状态
     * @param task
     */
    handlePublicAccountTaskIndex(task: Object) {
        // 根据执行列表找到没执行的那一步，即值为0的下标，根据下标去找到对应状态列表的值
        let obj = {
            index: -1,
            times: 0,// 找了几次
        }
        obj.index = PUBLIC_ACCOUNT_STATUS_LIST.findIndex(item => {
            obj.times++;
            // @ts-ignore
            return task[item] !== 1
        })
        return obj
    },

    /**
     * 处理一下公众号任务状态
     * @param task
     */
    handlePublicAccountTaskType(task: Object) {
        // 过滤找一下当前还没完成的步骤
        return Array.from(PUBLIC_ACCOUNT_STATE_LIST).filter(item =>
            // @ts-ignore
            task[item.isKey] >= 1 && task[item.key] !== null && task[item.key] !== 1
        )
    },

    /**
     * 处理返回的列表值
     * @param res
     */
    handleListData(res: Object) {
        let dataList = [], total = this.data.total;
        if (res?.code === 0 && res?.data?.data) {
            const newData = res.data.data || [];
            dataList = Array.isArray(newData) && newData.map((item, index) => {
                // 子任务处理循环
                item.list = Array.isArray(item.tasks) && item.tasks.map((task, i) => {
                    let stateList = [], isShowShare = false, isShowCopy = false;
                    // 待阅读，待分享，待分享阅读，待复制
                    // const {isDemandReadTime, isDemandShare, isDemandShareRead, isDemandClipboard} = task;
                    // 先判断 isDemandShare, isDemandShareRead, isDemandClipboard 等属性内容，
                    // 在大于等于1的情况下采取判断界面待做的任务状态

                    switch (task.type) {
                        case 1: // 公众号，要阅读，要分享，要分享阅读
                            stateList = this.handlePublicAccountTaskType(task);
                            isShowShare = true;
                            isShowCopy = false;
                            break;
                        case 2: // 视频号，只需要阅读
                            if(task.executeRouter !== 1){
                                stateList.push({
                                    key: 'executeRouter', label: '待完成', color: '#FF814A'
                                })
                            } else {
                                stateList.push({
                                    key: 'executeRouter', label: '已完成', color: '#389E0D'
                                })
                            }
                            isShowCopy = false;
                            break;
                        case 3: // 抖音，只需复制
                            if(task.executeClipboard !== 1){
                                stateList.push({
                                    key: 'executeClipboard', label: '待完成', color: '#FF814A'
                                })
                            } else {
                                stateList.push({
                                    key: 'executeClipboard', label: '已完成', color: '#389E0D'
                                })
                            }
                            isShowCopy = true;
                            break;
                        default:
                            break;
                    }
                    const {label: typeName, icon} = this.handleArticleType(task.type)
                    return {
                        ...task,
                        current: i,
                        route: task.route ?? '',// 处理一下null和undefined
                        typeName,// 文章类型
                        stateList,// 状态列表
                        isShowCopy,// 是否能复制
                        isShowShare,// 是否能分享
                        icon: '/image/' + icon + '.png',// 图标类型
                    }
                }) || []
                const {label: runText, color: bgColor, decoration} = this.handleMainTaskType(item.run);
                return {
                    ...item,
                    current: index,
                    remarks: item.remarks ?? '',// 处理一下null和undefined
                    bgColor,// 任务状态背景色
                    runText,// 当前总任务状态
                    decoration,// 当前总任务状态
                }
            }) || [];
            total = res.data.total || 0
        } else {
            handleErrCode(res.msg)
        }
        const oldList = this.data.taskList
        if (this.data.current > 1){// 上拉加载更多
            dataList = [...oldList, ...dataList]
        }
        this.setData({
            // backTaskList: dataList,
            taskList: dataList,
            total
        })
        // 主动触发一次
        // this.tabsChange({detail: {index: this.data.currentTab}})
    },

    /**
     * 主任务点击
     */
    taskClick(e) {
        const task = e.currentTarget.dataset.item || {};
        wx.navigateTo({
            url: `/pages/taskDetailAdmin/index?id=${task.id}`,
        })
    },

    /**
     * 点击子任务事件
     */
    subTaskClick(e: Object) {
        const task = e.currentTarget.dataset.item || {};
        switch (task.type) {
            case 1:// 公众号，只需要执行页面跳转就好
                this.taskExecuteReadTimeFun(task)
                break;
            case 2:// 视频号，只需要执行页面跳转就好
                this.taskExecuteRouteFun(task)
                break;
            case 3:// 抖音，这里啥也不干
                // this.copyString(task);
                break;
        }
    },
    /**
     * 执行公众号阅读
     */
    taskExecuteReadTimeFun(task) {
        wx.navigateTo({
            url: '/pages/publicDetail/index',
            success: async function (res) {
                // 通过eventChannel向被打开页面传送数据
                res.eventChannel.emit('acceptDataFromOpenerPage', {data: task, admin: true});
            }
        })
    },
    /**
     * 执行视频号跳转
     */
    taskExecuteRouteFun(task) {
        wx.openChannelsActivity({
            finderUserName: task.routeFinderUserName,
            feedId: task.routeFeedId,
            async success(res) {
                console.log(res)
                await taskExecuteRoute({
                    taskId: task.id,
                }).then(res => {
                    if (res?.code !== 0){
                        handleCode(res)
                    }
                }).catch(e => {
                    console.warn(e);
                    handleErrCode(e)
                })
            },
            fail(err) {
                console.log(err)
            }
        })
    },
    /**
     * 执行抖音复制到剪切板
     */
    async taskExecuteClipboardFun(task) {
        await taskExecuteClipboard({
            taskId: task.id,
        }).then(res => {
            handleCode(res)
        }).catch(e => {
            console.warn(e);
            handleErrCode(e)
        })
    },
    /**
     * 执行公众号分享
     */
    async taskExecuteShareFun(task) {
        await taskExecuteShare({
            taskId: task.id,
        }).then(res => {
            handleCode(res)
        }).catch(e => {
            console.warn(e);
            handleErrCode(e)
        })
    },

    /**
     * 分享
     */
    shareFun() {
    },
    /**
     * 列表滚动
     */
    viewScroll({detail = {scrollLeft, scrollTop, scrollHeight, scrollWidth, deltaX, deltaY}}){

    },

    /**
     * 生命周期函数--监听页面加载
     */
    onLoad(options) {
        const isWxmp = isWXMP(options)
        this.setData({
            isWxmp,
            options: JSON.stringify(options)
        })
        if (isWxmp){// 代表从公众号通知模板进来的，要去静默登录一下，登录有结果之后要记得赋值
            silentLogin(()=>{
                getCountInfo(this);
                this.searchFun({});
            });
        } else {
            getCountInfo(this);
        }
    },

    /**
     * 提示语
     */
    showToast(title){
        let params = {
            title,
        }
        toast && toast.show(params);
    },

    /**
     * 是否到底的判断
     */
    isEnd(){
        let {current,pageSize,total} = this.data;
        if (total && current !== 1 && current * pageSize >= total){
            this.showToast('已经到底了')
            return true
        } else {
            return false
        }
    },

    /**
     * 生命周期函数--监听页面初次渲染完成
     */
    onReady() {
        toast = this.selectComponent("#toast")
    },

    /**
     * 生命周期函数--监听页面显示
     */
    onShow() {
        !this.data.isWxmp && this.tabsChange({detail: {index: this.data.currentTab}});// 没有token采取获取
        wx.hideShareMenu({
            // menus: ['shareAppMessage', 'shareTimeline'],// 隐藏分享到朋友和分享到朋友圈
            menus: ['shareTimeline'],// 隐藏分享到朋友和分享到朋友圈
        })
        wx.showShareMenu({
            withShareTicket: true,
            menus: [
                'shareAppMessage', // 分享给朋友
                // 'shareTimeline',// 分享到朋友圈
            ]
        });
    },

    /**
     * 生命周期函数--监听页面隐藏
     */
    onHide() {

    },

    /**
     * 生命周期函数--监听页面卸载
     */
    onUnload() {

    },

    /**
     * 页面相关事件处理函数--监听用户下拉动作
     */
    onPullDownRefresh() {

    },

    /**
     * scroll-view 下拉刷新
     */
    refresherPulling(){
        this.setData({
            triggered: true
        })
    },

    /**
     * 刷新函数
     */
    refreshFun(e:object, current = 1){
        // 标题栏显示刷新图标，转圈圈
        wx.showNavigationBarLoading()

        this.searchFun({current});
        clearTimeout(this.data.searchTimeout);
        let searchTimeout = setTimeout(() => {
            this.searchFinally()
        }, 2000);
        this.setData({
            searchTimeout,
        })
    },

    /**
     * 下拉加载更多数据函数
     */
    scrollToLowerFun(){
        if (this.isEnd()){
            return
        }
        // 调用刷新函数
        this.refreshFun({},this.data.current + 1)
    },

    /**
     * 搜索最终
     */
    searchFinally(){
        clearTimeout(this.data.searchTimeout)
        // 标题栏隐藏刷新转圈圈图标
        wx.hideNavigationBarLoading();
        wx.stopPullDownRefresh();
        wx.hideLoading();
        this.setData({
            triggered: false
        })
    },

    /**
     * 页面上拉触底事件的处理函数
     */
    onReachBottom() {

    },

    /**
     * 用户点击右上角分享
     */
    onShareAppMessage() {

    }
})